{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "# भाग 9 - इंट्रो टू एन्क्रिप्टेड प्रोग्राम\n",
    "\n",
    "यावर विश्वास ठेवा किंवा नाही, एनक्रिप्टेड डेटासह गणना करणे शक्य आहे. दुऱ्या शब्दांत, प्रोग्राम चालवणे शक्य आहे जेथे **प्रोग्राममधील सर्व चल एन्क्रिप्ट केलेले आहेत!**\n",
    "\n",
    "या ट्यूटोरियल मध्ये आपण एनक्रिप्टेड संगणनाची मूलभूत साधने पार पाडणार आहोत. विशेषतः आपण सिक्युर मल्टी-पार्टी कंप्यूटेशन नावाच्या लोकप्रिय दृष्टिकोनावर लक्ष केंद्रित करणार आहोत. या पाठात आपण एन्क्रिप्टेड कॅल्क्युलेटर कसे तयार करावे जे एनक्रिप्टेड नंबरवर गणना करू शकतात.\n",
    "\n",
    "लेखक:\n",
    "- Andrew Trask - Twitter: [@iamtrask](https://twitter.com/iamtrask)\n",
    "- Théo Ryffel - Github: [@LaRiffle](https://github.com/Laiffiff)\n",
    "\n",
    "संदर्भ:\n",
    "- Morten Dahl - [ब्लॉग](https://mortendahl.github.io) - Twitter: [@mortendahlcs](https://twitter.com/mortendahlcs)\n",
    "\n",
    "\n",
    "अनुवादक/संपादक:\n",
    "- Krunal Kshirsagar - Twitter: [@krunal_wrote](https://twitter.com/krunal_wrote) - Github: [@Noob-can-Compile](https://github.com/Noob-can-Compile)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "# चरण 1: सिक्युर मल्टी-पार्टी कंप्यूटेशन वापरुन एनक्रिप्शन करणे\n",
    "\n",
    "SMPC पहिल्या दृष्टीक्षेपात \"encryption\" चा एक विलक्षण प्रकार आहे. व्हेरिएबलला एनक्रिप्ट करण्यासाठी सार्वजनिक / खाजगी की वापरण्याऐवजी, प्रत्येक मूल्य एकाधिक `shares` मध्ये विभागले जाते, त्यातील प्रत्येक खाजगी की प्रमाणे कार्य करते. सामान्यत: हे `shares` भाग 2 किंवा अधिक _owners_मध्ये वितरीत केले जातील. अशाप्रकारे, व्हेरिएबल डिक्रिप्ट करण्यासाठी, सर्व मालकांनी डिक्रिप्शनला परवानगी देण्याचे मान्य केले पाहिजे. थोडक्यात, प्रत्येकाकडे खासगी की असते.\n",
    "\n",
    "### Encrypt()\n",
    "\n",
    "तर, चला असे म्हणा की आपल्याला व्हेरिएबल x \"एनक्रिप्ट\" करायचा आहे, असे आपण पुढील मार्गाने करू शकतो.\n",
    "\n",
    " > एंक्रिप्शन फ्लोट्स किंवा वास्तविक संख्या वापरत नाही, परंतु गणिताच्या जागेवर [integer quotient ring](http://mathworld.wolfram.com/QuotientRing.html) म्हणतात, जो मुळात `0` आणि `Q-1` दरम्यान पूर्णांक असतो, जेथे `Q` प्राइम आणि \"पुरेशी\" असते जेणेकरून आपल्या प्रयोगांमध्ये वापरलेल्या सर्व संख्या समाविष्ट होतील. प्रॅक्टिसमध्ये, 'x' पूर्णांकचे मूल्य देऊन, आपण रिंगमध्ये फिट होण्यासाठी `x % Q` देतो. (म्हणूनच आपण `x '> Q` हा अंक वापरणे टाळत आहोत).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "Q = 1234567891011"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "def encrypt(x):\n",
    "    share_a = random.randint(-Q,Q)\n",
    "    share_b = random.randint(-Q,Q)\n",
    "    share_c = (x - share_a - share_b) % Q\n",
    "    return (share_a, share_b,  share_c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(890804432397, -2305631655, 346069090294)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "encrypt(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "आपण येथे पाहू शकता की आम्ही आपल्या व्हेरिएबल `x` ला 3 वेगवेगळ्या शेअर्समध्ये विभागले आहे, जे 3 वेगवेगळ्या मालकांना पाठवले जाऊ शकतात.\n",
    "\n",
    "### Decrypt()\n",
    "\n",
    "जर आपल्याला हे 3 समभाग डीक्रिप्ट करायचे असतील तर आपल्याला फक्त त्यांना एकत्र करुन निकालाचे मॉड्यूलस (mod Q) घेऊ शकू."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decrypt(*shares):\n",
    "    return sum(shares) % Q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b,c = encrypt(25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "decrypt(a, b, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "महत्त्वाचे म्हणजे लक्षात घ्या की जर आपण केवळ दोन शेअर्ससह (shares) डिक्रिप्ट करण्याचा प्रयत्न केला तर डिक्रिप्शन कार्य करत नाही!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "778460474681"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "decrypt(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "अशा प्रकारे, मूल्य डीक्रिप्ट करण्यासाठी आपल्याला सर्व मालकांच्या  सहभागाची आवश्यकता आहे. हे अशा प्रकारे आहे की `shares` खाजगी की प्रमाणे कार्य करतात, त्यातील सर्व मूल्य डीक्रिप्ट करण्यासाठी उपस्थित असणे आवश्यक आहे."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "# चरण 2: SMPC वापरुन मूलभूत अंकगणित\n",
    "\n",
    "तथापि, **व्हेरिएबल्स अजूनही एनक्रिप्ट केले जात असताना** सुरक्षित बहु-पक्षीय संगणनांची खरोखर अपवादात्मक मालमत्ता गणना करण्याची क्षमता आहे. खाली साधे भर दाखवू."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = encrypt(25)\n",
    "y = encrypt(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(x, y):\n",
    "    z = list()\n",
    "    # the first worker adds their shares together\n",
    "    z.append((x[0] + y[0]) % Q)\n",
    "    \n",
    "    # the second worker adds their shares together\n",
    "    z.append((x[1] + y[1]) % Q)\n",
    "    \n",
    "    # the third worker adds their shares together\n",
    "    z.append((x[2] + y[2]) % Q)\n",
    "    \n",
    "    return z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "decrypt(*add(x,y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "### यश !!!\n",
    "\n",
    "आणि तुम्हाला ते मिळालेच! जर प्रत्येक कामगार (स्वतंत्रपणे) त्यांचे शेअर्स एकत्र जोडत असेल तर परिणामी शेअर्स योग्य मूल्यावर (25 + 5 == 30) डिक्रिप्ट होतील.\n",
    "\n",
    "जसे हे निष्पन्न होते, SMPC प्रोटोकॉल अस्तित्त्वात आहेत जे पुढील क्रियांसाठी या एनक्रिप्टेड संगणनास अनुमती देऊ शकतात:\n",
    "- जोड (जे आपण आत्ताच पाहिले आहे)\n",
    "- गुणाकार\n",
    "- तुलना\n",
    "\n",
    "आणि या मूलभूत आदिमांचा वापर करून आपण अनियंत्रित गणना करू शकतो !!!\n",
    "\n",
    "पुढील विभागात, आपण ही ऑपरेशन्स करण्यासाठी PySyft लायब्ररी कशी वापरावी हे शिकणार आहोत!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "# चरण 3: PySyft वापरुन SMPC\n",
    "\n",
    "मागील भागात, आपण SMPC च्या आसपास काम करणारे काही मूलभूत अंतर्ज्ञान अधोरेखित केले. तथापि, प्रत्यक्षात आपले एनक्रिप्टेड प्रोग्राम्स लिहिताना आपण स्वतः सर्व आदिम ऑपरेशन्स स्वतःच लिहायच्या नसतात. तर, या विभागात आपण PySyft चा वापर करून एनक्रिप्टेड कंप्यूटेशन कसे करावे याबद्दल मूलभूत गोष्टी जाणून घेणार आहोत. विशेषत: आपण पूर्वी नमूद केलेले 3 आदिम कसे करावे यावर लक्ष केंद्रित करणार आहोत: जोड, गुणाकार आणि तुलना.\n",
    "\n",
    "प्रथम, आपल्याला काही आभासी कामगार (Virtual Workers) तयार करण्याची आवश्यकता आहे (जे, आशा आहे की आपण आता आमच्या मागील शिकवण्यांसह परिचित आहात)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import syft as sy\n",
    "hook = sy.TorchHook(torch)\n",
    "\n",
    "bob = sy.VirtualWorker(hook, id=\"bob\")\n",
    "alice = sy.VirtualWorker(hook, id=\"alice\")\n",
    "bill = sy.VirtualWorker(hook, id=\"bill\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "### मूलभूत एन्क्रिप्शन / डिक्रिप्शन\n",
    "\n",
    "एन्क्रिप्शन कोणत्याही PySyft टेन्सर आणि .share() ला कॉल करून घेण्याइतकेच सोपे आहे. डिक्रिप्शन सामायिक व्हेरिएबलवर .get () वर कॉल करण्याइतके सोपे आहे. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = torch.tensor([25])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([25])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "encrypted_x = x.share(bob, alice, bill)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([25])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "encrypted_x.get()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "### एन्क्रिप्ट आणकांचे आत्मपरीक्षण करणे\n",
    "\n",
    "एन्क्रिप्ट आणकांचे आत्मपरीक्षण करणे\n",
    "जर आपण Bob, Alice आणि Bill चे कामगारांकडे पाहिले तर आपण तयार झालेले शेअर्स पाहू शकतो."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bob._objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = torch.tensor([25]).share(bob, alice, bill)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([3212861001891376707])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Bob's share\n",
    "bobs_share = list(bob._objects.values())[0]\n",
    "bobs_share"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([61371170032936135])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Alice's share\n",
    "alices_share = list(alice._objects.values())[0]\n",
    "alices_share"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1337453846503075087])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Bill's share\n",
    "bills_share = list(bill._objects.values())[0]\n",
    "bills_share"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "आणि जर आपल्याला पाहिजे असेल तर आपण पूर्वी बोललेल्या समान पध्दतीचा वापर करून ही मूल्ये डीक्रिप्ट करु शकता !!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([25])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Q = x.child.field\n",
    "\n",
    "(bobs_share + alices_share + bills_share) % Q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "जसे आपण पाहू शकता, जेव्हा आपण `.share()` कॉल केला तेव्हा त्यास फक्त तीन शेअर्समध्ये मूल्य विभागले आणि प्रत्येक पक्षाला एक वाटा पाठविला!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "# एन्क्रिप्टेड अंकगणित\n",
    "\n",
    "आणि आता तुम्ही पाहता की आपण मूळ मूल्यांवर अंकगणित करू शकतो! एपीआय तयार केले आहे जेणेकरून आपण PyTorch टेन्सर सामान्य करण्यासारखे गणित करू शकतो."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = torch.tensor([25]).share(bob,alice)\n",
    "y = torch.tensor([5]).share(bob,alice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([30])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = x + y\n",
    "z.get()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([20])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = x - y\n",
    "z.get()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "# एन्क्रिप्ट गुणाकार\n",
    "\n",
    "गुणाकार करण्यासाठी आपल्याला एक अतिरिक्त पक्षाची आवश्यकता आहे जी सलग यादृच्छिक संख्या निर्माण करण्यासाठी जबाबदार असेल (आणि इतर कोणत्याही पक्षांसह एकत्र येत नाही). आपण या व्यक्तीस \"क्रिप्टो प्रदाता\"(\"crypto provider\") म्हणतो. सर्व सखोल हेतूंसाठी, क्रिप्टो प्रदाता फक्त एक अतिरिक्त व्हर्च्युअल वर्कर (VirtualWorker) आहे, परंतु हे कबूल करणे महत्वाचे आहे की क्रिप्टो प्रदाता \"मालक\" नाही ज्यात तो / तिचा शेअर्सचा मालक नाही परंतु कोणावर विश्वास ठेवला जाऊ शकतो विद्यमान कोणत्याही भागधारकांशी करार करीत नाही."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "crypto_provider = sy.VirtualWorker(hook, id=\"crypto_provider\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = torch.tensor([25]).share(bob,alice, crypto_provider=crypto_provider)\n",
    "y = torch.tensor([5]).share(bob,alice, crypto_provider=crypto_provider)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([125])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# multiplication\n",
    "\n",
    "z = x * y\n",
    "z.get()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "आपण मॅट्रिक्स गुणाकार देखील करू शकता"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = torch.tensor([[1, 2],[3,4]]).share(bob,alice, crypto_provider=crypto_provider)\n",
    "y = torch.tensor([[2, 0],[0,2]]).share(bob,alice, crypto_provider=crypto_provider)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[2, 4],\n",
       "        [6, 8]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# matrix multiplication\n",
    "\n",
    "z = x.mm(y)\n",
    "z.get()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "# एन्क्रिप्टेड तुुलना\n",
    "\n",
    "खाजगी मूल्यांमध्ये खासगी तुलना करणे देखील शक्य आहे. आम्ही येथे SecureNN प्रोटोकॉलवर अवलंबून आहोत, ज्याचा तपशील [येथे](https://eprint.iacr.org/2018/442.pdf) मिळू शकतो. तुलनाचा परिणाम देखील एक खाजगी सामायिक टेन्सर आहे."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = torch.tensor([25]).share(bob,alice, crypto_provider=crypto_provider)\n",
    "y = torch.tensor([5]).share(bob,alice, crypto_provider=crypto_provider)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = x > y\n",
    "z.get()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = x <= y\n",
    "z.get()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = x == y\n",
    "z.get()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = x == y + 20\n",
    "z.get()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "आपण max ऑपरेशन्स देखील करू शकता"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([4])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = torch.tensor([2, 3, 4, 1]).share(bob,alice, crypto_provider=crypto_provider)\n",
    "x.max().get()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([4, 3])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = torch.tensor([[2, 3], [4, 1]]).share(bob,alice, crypto_provider=crypto_provider)\n",
    "max_values, max_ids = x.max(dim=0)\n",
    "max_values.get()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "# अभिनंदन !!! - समुदायात सामील होण्याची वेळ आली!\n",
    "\n",
    "\n",
    "हे नोटबुक ट्यूटोरियल पूर्ण केल्याबद्दल अभिनंदन! आपण याचा आनंद घेत असल्यास आणि एआय(AI) आणि एआय सप्लाय चेन  (डेटा) च्या विकेंद्रित(Decentralized) मालकीच्या गोपनीयतेच्या संरक्षणाच्या दिशेने चळवळीत सामील होऊ इच्छित असाल तर आपण हे खालील प्रकारे करू शकता!\n",
    "\n",
    "### Pysyft ला Github वर Star करा!\n",
    "\n",
    "आमच्या समुदायाला मदत करण्याचा सर्वात सोपा मार्ग म्हणजे फक्त गिटहब(GitHub) रेपो(Repo) तारांकित(Star) करणे! हे आम्ही तयार करीत असलेल्या छान साधनांविषयी जागरूकता वाढविण्यास मदत करते.\n",
    "\n",
    "- [Star PySyft](https://github.com/OpenMined/PySyft)\n",
    "\n",
    "### आमच्या Slack मध्ये सामील व्हा!\n",
    "\n",
    "\n",
    "नवीनतम प्रगतीवर अद्ययावत राहण्याचा उत्तम मार्ग म्हणजे आमच्या समुदायामध्ये सामील होणे! आपण [http://slack.openmined.org](http://slack.openmined.org) येथे फॉर्म भरुन तसे करू शकता.\n",
    "\n",
    "### एका कोड प्रोजेक्टमध्ये सामील व्हा!\n",
    "\n",
    "आमच्या समुदायामध्ये योगदानाचा उत्तम मार्ग म्हणजे कोड योगदानकर्ता बनणे! कोणत्याही वेळी आपण (PySyft GitHub Issues Page) वर  जाऊ शकता आणि \"Project\" साठी फिल्टर करू शकता. हे आपण कोणत्या प्रकल्पांमध्ये सामील होऊ शकता याबद्दल विहंगावलोकन देणारी सर्व उच्च स्तरीय तिकिटे दर्शवेल! आपण एखाद्या प्रकल्पात सामील होऊ इच्छित नसल्यास, परंतु आपण थोडं कोडिंग करू इच्छित असाल तर आपण \"good first issues\" म्हणून चिन्हांकित गिटहब(GitHub) अंक शोधून आणखी \"one off\" मिनी-प्रकल्प(mini project) शोधू शकता.\n",
    "\n",
    "- [PySyft Projects](https://github.com/OpenMined/PySyft/issues?q=is%3Aopen+is%3Aissue+label%3AProject)\n",
    "- [Good First Issue Tickets](https://github.com/OpenMined/PySyft/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22)\n",
    "\n",
    "### दान करा\n",
    "\n",
    "आपल्याकडे आमच्या कोडेबेसमध्ये योगदान देण्यास वेळ नसल्यास, परंतु तरीही आपल्याला समर्थन द्यावयाचे असल्यास आपण आमच्या मुक्त संग्रहात बॅकर देखील होऊ शकता. सर्व देणगी आमच्या वेब होस्टिंग आणि हॅकॅथॉन आणि मेटअप्स सारख्या इतर सामुदायिक खर्चाकडे जातात!\n",
    "\n",
    "[OpenMined's Open Collective Page](https://opencollective.com/openmined)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "nbTranslate": {
   "displayLangs": [
    "hi"
   ],
   "hotkey": "alt-t",
   "langInMainMenu": true,
   "sourceLang": "en",
   "targetLang": "hi",
   "useGoogleTranslate": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}